import deepClone from '@/libs/deepClone'
import useGlobalAPI from '../useGlobalAPI'
import { debounce } from '@/libs/debounce'
import {
  EditDevTypeConConfigOption,
  EditDevTypeConConfigOptionParamConf,
  EditDevTypeConConfigOptionParamConfDataMODBUS,
  EditDevTypeConConfigOptionParamConfJSON,
  EditDevTypeConConfigOptionParamConfMODBUS
} from '@/api/device'
import { message } from '@/libs/global/antDesignVue'

function useDevTypeConConfig() {
  const { store } = useGlobalAPI()

  // 原始 默认通信配置数据
  const defaultDevTypeConConfig: DeviceType.ConConfig = {
    devTypeCCId: -1,
    devTypeTxTypeCode: '0017',
    devTypeDataTypeCode: '0019',
    devTypeHeart: '',
    devTypeId: -1,
    paramConfList: []
  }
  // 原始 通信配置数据
  let devTypeConConfig = ref<DeviceType.ConConfig>(deepClone(defaultDevTypeConConfig))
  function setDevTypeConConfig(data: DeviceType.ConConfig) {
    devTypeConConfig.value = data
  }

  // 组件 默认通信配置数据
  const defaultDevTypeModuleConConfig: AddDevType.DevTypeConConfigSign = {
    devTypeId: -1,
    devTypeCCId: -1,
    devTypeHeart: '',
    /**通讯类型 MQTT或SOCKET*/
    devTypeTxTypeCode: '0017',
    /**通讯数据格式 JSON或MODBUS */
    devTypeDataTypeCode: '0019',
    txConf: {
      confId: -1,
      devTypeId: -1,
      jdtParamConfDesc: '',
      jdtParamConfFlag: '0',
      paramConfDataList: [],
      sort: '0'
    }
  }
  // 组件 通信配置数据
  let devTypeModuleConConfig = ref<AddDevType.DevTypeConConfigSign>(
    deepClone(defaultDevTypeModuleConConfig)
  )
  function setDevTypeModuleConConfig(data: AddDevType.DevTypeConConfigSign) {
    devTypeModuleConConfig.value = data
  }

  // const getDevTypeModuleConConfigOperatingrecord = computed<EditDevTypeConConfigOption | undefined>(
  //   () => {
  //     if (devTypeConConfig.value.devTypeId === -1 || !devTypeConConfig.value.devTypeId) {
  //       return undefined
  //     }

  //     if (
  //       devTypeModuleConConfig.value.devTypeId === -1 ||
  //       !devTypeModuleConConfig.value.devTypeId
  //     ) {
  //       return undefined
  //     }

  //     let defaultConConfig = devTypeConConfig2devTypeModuleConConfig(devTypeConConfig.value, false)

  //     /**
  //      * 将数据强制转为EditDevTypeConConfigOption
  //      *
  //      * 方便添加makeProperty
  //      *  */
  //     // let conConfig = deepClone(devTypeModuleConConfig.value) as  AddDevType.DevTypeConConfigSign

  //     let returnData: EditDevTypeConConfigOption | undefined = undefined

  //     if (defaultConConfig.devTypeDataTypeCode === '0019') {
  //       let conConfig = deepClone(
  //         devTypeModuleConConfig.value
  //       ) as AddDevType.DevTypeConConfigSign<EditDevTypeConConfigOptionParamConfJSON>

  //       let txConf = conConfig.txConf

  //       /**
  //        *
  //        *
  //        *   */

  //       if (!txConf.confId) {
  //         txConf.makeProperty = 'add'
  //         if (!txConf.paramConfDataList.length) {
  //           message.warning('请添加参数')
  //           return undefined
  //         }

  //         for (let i = 0; i < txConf.paramConfDataList.length; i++) {
  //           const paramConfData = txConf.paramConfDataList[i]
  //           paramConfData.confId = txConf.confId

  //           let flag = jsonParamConfDataIsOk(paramConfData)
  //           if (!flag) {
  //             return undefined
  //           }
  //           paramConfData.makeProperty = 'add'
  //         }
  //       } else {
  //         txConf.makeProperty = ''

  //         let defaultParamConfDataList = (defaultConConfig.txConf as AddDevType.TxConf_JSON)
  //           .paramConfDataList

  //         let paramConfDataList = txConf.paramConfDataList

  //         for (let i = 0; i < paramConfDataList.length; i++) {
  //           const paramConfData = paramConfDataList[i]
  //           paramConfData.confId = txConf.confId

  //           let flag = jsonParamConfDataIsOk(paramConfData)
  //           if (!flag) {
  //             return undefined
  //           }

  //           /**
  //            * 初始将json的所有参数的操作属性改为delete
  //            *
  //            * 通过后续对比 在更改为edit add 或者 空字符
  //            */
  //           paramConfData.makeProperty = 'delete'

  //           const defaultParamConfDataIndex = defaultParamConfDataList.findIndex(
  //             item => item.confDataId === paramConfData.confDataId
  //           )

  //           /**如果有值 比对必要属性是否相同 */
  //           if (defaultParamConfDataIndex !== -1) {
  //             const defaultParamConfData = defaultParamConfDataList[defaultParamConfDataIndex]

  //             let flag = jsonParamConfDataIsDiff(defaultParamConfData, paramConfData)

  //             if (flag) {
  //               // 如果不同将操纵属性改为edit
  //               paramConfData.makeProperty = 'edit'
  //               txConf.makeProperty = 'edit'
  //             } else {
  //               // 如果不同将操纵属性改为edit
  //               paramConfData.makeProperty = ''
  //             }
  //           } else {
  //             // 如果没值 视为添加
  //             paramConfData.makeProperty = 'add'
  //             txConf.makeProperty = 'edit'
  //           }
  //         }
  //       }

  //       returnData = {
  //         devTypeCCId: conConfig.devTypeCCId,
  //         devTypeId: conConfig.devTypeId,
  //         devTypeTxTypeCode: conConfig.devTypeTxTypeCode,
  //         devTypeDataTypeCode: conConfig.devTypeDataTypeCode,
  //         devTypeHeart: conConfig.devTypeHeart,
  //         paramConfList: [conConfig.txConf]
  //       }
  //     } else {
  //       let conConfig = deepClone(devTypeModuleConConfig.value) as AddDevType.DevTypeConConfigSign<
  //         EditDevTypeConConfigOptionParamConfMODBUS[]
  //       >

  //       let defaultTxConfList = defaultConConfig.txConf as AddDevType.TxConf_MODBUS[]

  //       let txConfList = (
  //         conConfig as unknown as AddDevType.DevTypeConConfigSign<
  //           EditDevTypeConConfigOptionParamConfMODBUS[]
  //         >
  //       ).txConf

  //       for (let i = 0; i < txConfList.length; i++) {
  //         const txConf = txConfList[i]
  //         /**
  //          * 初始将modbus所有参数集的操作属性改为delete
  //          *
  //          * 通过后续对比 在更改为edit add 或者 空字符
  //          */
  //         txConf.makeProperty = 'delete'

  //         let defaultTxConfIndex = defaultTxConfList.findIndex(
  //           item => item.confId === txConf.confId
  //         )

  //         if (defaultTxConfIndex !== -1) {
  //           txConf.makeProperty = ''

  //           let defaultTxConf = defaultTxConfList[defaultTxConfIndex]

  //           let flag = modbusTxConfDataIsDiff(defaultTxConf, txConf)

  //           let defaultParamConfDataList = defaultTxConf.paramConfDataList
  //           let paramConfDataList = txConf.paramConfDataList

  //           for (let j = 0; j < paramConfDataList.length; j++) {
  //             const paramConfData = paramConfDataList[j]

  //             /**
  //              * 初始将modbus所有参数的操作属性改为delete
  //              *
  //              * 通过后续对比 在更改为edit add 或者 空字符
  //              */
  //             paramConfData.makeProperty = 'delete'

  //             let defaultParamConfDataIndex = defaultParamConfDataList.findIndex(
  //               item => item.confDataId === paramConfData.confDataId
  //             )

  //             if (defaultParamConfDataIndex !== -1) {
  //               let defaultParamConfData = defaultParamConfDataList[defaultParamConfDataIndex]

  //               let flag = modbusParamConfDataIsDiff(defaultParamConfData, paramConfData)
  //               if (flag) {
  //                 // 如果不同将操纵属性改为edit
  //                 paramConfData.makeProperty = 'edit'
  //               } else {
  //                 // 如果不同将操纵属性改为edit
  //                 paramConfData.makeProperty = ''
  //               }
  //             } else {
  //               paramConfData.makeProperty = 'add'
  //             }
  //           }
  //         } else {
  //           // 默认数据中没有对应的数据集，视为添加
  //           txConf.makeProperty = 'add'

  //           // 数据集添加时，内部所有参数的操作属性都为添加
  //           for (let j = 0; j < txConf.paramConfDataList.length; j++) {
  //             const paramConfData = txConf.paramConfDataList[j]
  //             paramConfData.makeProperty = 'add'
  //           }
  //         }
  //       }

  //       returnData = {
  //         devTypeCCId: conConfig.devTypeCCId,
  //         devTypeId: conConfig.devTypeId,
  //         devTypeTxTypeCode: conConfig.devTypeTxTypeCode,
  //         devTypeDataTypeCode: conConfig.devTypeDataTypeCode,
  //         devTypeHeart: conConfig.devTypeHeart,
  //         paramConfList: conConfig.txConf
  //       }
  //     }

  //     return returnData
  //   }
  // )

  // /**
  //  * 传入两个json协议的检测参数配置，比较是否有数据不同
  //  *
  //  * @return boolean  true:不同 false:相同
  //  *  */
  // function jsonParamConfDataIsDiff(
  //   defaultData: AddDevType.ParamConfData_JSON,
  //   currentData: AddDevType.ParamConfData_JSON
  // ): boolean {
  //   if (defaultData.confId !== currentData.confId) {
  //     console.error(defaultData)
  //     console.error(currentData)
  //     return true
  //   }
  //   if (defaultData.confDataId !== currentData.confDataId) {
  //     console.error(defaultData)
  //     console.error(currentData)
  //     return true
  //   }
  //   if (defaultData.paramCode !== currentData.paramCode) {
  //     console.error(defaultData)
  //     console.error(currentData)
  //     return true
  //   }
  //   if (defaultData.paramDesc !== currentData.paramDesc) {
  //     console.error(defaultData)
  //     console.error(currentData)
  //     return true
  //   }
  //   if (defaultData.sort !== currentData.sort) {
  //     console.error(defaultData)
  //     console.error(currentData)
  //     return true
  //   }
  //   if (defaultData.reserveNum != currentData.reserveNum) {
  //     console.error(defaultData)
  //     console.error(currentData)
  //     return true
  //   }
  //   if (defaultData.paramName !== currentData.paramName) {
  //     console.error(defaultData)
  //     console.error(currentData)
  //     return true
  //   }
  //   return false
  // }

  // /**
  //  * 传入json协议的检测参数配置，查看数据是否完整
  //  *
  //  * @return boolean  true:完整 false:不完整
  //  *  */
  // function jsonParamConfDataIsOk(data: AddDevType.ParamConfData_JSON): boolean {
  //   if (!data.paramCode) {
  //     console.error(data)
  //     message.warning('请选择监测参数')
  //     return false
  //   }

  //   if (!data.sort) {
  //     console.error(data)
  //     return false
  //   }

  //   let reserveNum = Number(data.reserveNum)
  //   if (isNaN(reserveNum)) {
  //     console.error(data)
  //     message.warning('请输入保留位数')

  //     return false
  //   }

  //   // 不用判断检测参数名称
  //   // 选择的时候会自动赋值
  //   // if (!data.paramName) {
  //   //   console.error(data)
  //   //   return false
  //   // }

  //   return true
  // }

  // /**
  //  * 传入两个modbus协议的检测参数配置，比较是否有数据不同
  //  *
  //  * @return boolean  true:不同 false:相同
  //  *  */
  // function modbusParamConfDataIsDiff(
  //   defaultData: AddDevType.ParamConfData_MODBUS,
  //   currentData: AddDevType.ParamConfData_MODBUS
  // ): boolean {
  //   if (defaultData.confId !== currentData.confId) {
  //     console.error(defaultData)
  //     console.error(currentData)
  //     return true
  //   }
  //   if (defaultData.confDataId !== currentData.confDataId) {
  //     console.error(defaultData)
  //     console.error(currentData)
  //     return true
  //   }
  //   if (defaultData.paramCode !== currentData.paramCode) {
  //     console.error(defaultData)
  //     console.error(currentData)
  //     return true
  //   }
  //   if (defaultData.paramName !== currentData.paramName) {
  //     console.error(defaultData)
  //     console.error(currentData)
  //     return true
  //   }
  //   if (defaultData.reserveNum != currentData.reserveNum) {
  //     console.error(defaultData)
  //     console.error(currentData)
  //     return true
  //   }
  //   if (defaultData.byteType !== currentData.byteType) {
  //     console.error(defaultData)
  //     console.error(currentData)
  //     return true
  //   }
  //   if (defaultData.dataType !== currentData.dataType) {
  //     console.error(defaultData)
  //     console.error(currentData)
  //     return true
  //   }
  //   if (defaultData.startHexStr !== currentData.startHexStr) {
  //     console.error(defaultData)
  //     console.error(currentData)
  //     return true
  //   }
  //   if (defaultData.numMade !== currentData.numMade) {
  //     console.error(defaultData)
  //     console.error(currentData)
  //     return true
  //   }
  //   if (defaultData.paramDesc !== currentData.paramDesc) {
  //     console.error(defaultData)
  //     console.error(currentData)
  //     return true
  //   }
  //   if (defaultData.sort !== currentData.sort) {
  //     console.error(defaultData)
  //     console.error(currentData)
  //     return true
  //   }

  //   return false
  // }

  // /**
  //  * 传入两个modbus协议的通信配置，比较是否有数据不同
  //  *
  //  * @return boolean  true:不同 false:相同
  //  *  */
  // function modbusTxConfDataIsDiff(
  //   defaultData: AddDevType.TxConf_MODBUS,
  //   currentData: AddDevType.TxConf_MODBUS
  // ): boolean {
  //   if (defaultData.confId !== currentData.confId) {
  //     console.error(defaultData)
  //     console.error(currentData)
  //     return true
  //   }
  //   if (defaultData.devTypeId !== currentData.devTypeId) {
  //     console.error(defaultData)
  //     console.error(currentData)
  //     return true
  //   }
  //   if (defaultData.funCode !== currentData.funCode) {
  //     console.error(defaultData)
  //     console.error(currentData)
  //     return true
  //   }
  //   if (defaultData.paramConfDataList !== currentData.paramConfDataList) {
  //     console.error(defaultData)
  //     console.error(currentData)
  //     return true
  //   }
  //   if (defaultData.addressCode !== currentData.addressCode) {
  //     console.error(defaultData)
  //     console.error(currentData)
  //     return true
  //   }
  //   if (defaultData.mdtParamConfDesc !== currentData.mdtParamConfDesc) {
  //     console.error(defaultData)
  //     console.error(currentData)
  //     return true
  //   }
  //   if (defaultData.sort !== currentData.sort) {
  //     console.error(defaultData)
  //     console.error(currentData)
  //     return true
  //   }

  //   return false
  // }

  // function modbusParamConfDataIsOk(data: AddDevType.ParamConfData_MODBUS): boolean {
  //   if (data.confId != -1 && !data.confId) {
  //     console.error(data)
  //     return false
  //   }

  //   if (!data.paramCode) {
  //     console.error(data)
  //     message.warning('请选择监测参数')

  //     return false
  //   }
  //   // if ( !data.paramName) {
  //   //   console.error(data)
  //   //   return false
  //   // }

  //   let reserveNum = Number(data.reserveNum)
  //   if (isNaN(reserveNum)) {
  //     console.error(data)
  //     message.warning('请输入保留位数')
  //     return false
  //   }

  //   if (!data.startHexStr) {
  //     console.error(data)
  //     message.warning('请输入起始位')
  //     return false
  //   }

  //   if (data.startHexStr.length !== 4) {
  //     console.error(data)
  //     message.warning('起始位长度为4')
  //     return false
  //   }

  //   return true
  // }

  // 重置配置状态
  function initDevTypeConConfig(option?: {
    initDevTypeConConfig?: boolean
    initDevTypeModuleConConfig?: boolean
  }) {
    devTypeConConfig.value = deepClone(defaultDevTypeConConfig)
    devTypeModuleConConfig.value = deepClone(defaultDevTypeModuleConConfig)
  }

  /**将设备类型的通信配置数据 转为 组件所需的数据 */
  function devTypeConConfig2devTypeModuleConConfig(
    conConfig: DeviceType.ConConfig,
    isUpdate?: boolean
  ): AddDevType.DevTypeConConfigSign {
    // 存储原始数据
    isUpdate !== false && setDevTypeConConfig(deepClone(conConfig) as typeof conConfig)

    // ----------------------------------- 数据类型转换 -----------------------------------
    let devTypeModuleConConfig: AddDevType.DevTypeConConfigSign | undefined = undefined
    if (conConfig.devTypeDataTypeCode == '0019') {
      if (conConfig.paramConfList.length === 1) {
        let jsonConf = conConfig.paramConfList[0] as DeviceType.ParamConfJSON

        devTypeModuleConConfig = {
          devTypeCCId: conConfig.devTypeCCId,
          devTypeId: conConfig.devTypeId,
          devTypeHeart: conConfig.devTypeHeart,
          devTypeTxTypeCode: conConfig.devTypeTxTypeCode,
          devTypeDataTypeCode: conConfig.devTypeDataTypeCode,
          txConf: {
            confId: jsonConf.confId,
            devTypeId: jsonConf.devTypeId,
            jdtParamConfDesc: jsonConf.jdtParamConfDesc || '',
            jdtParamConfFlag: jsonConf.jdtParamConfFlag,
            paramConfDataList: jsonConf.paramConfDataList,
            sort: jsonConf.sort
          }
        }
      } else {
        devTypeModuleConConfig = {
          devTypeCCId: conConfig.devTypeCCId,
          devTypeId: conConfig.devTypeId,
          devTypeHeart: conConfig.devTypeHeart,
          devTypeTxTypeCode: conConfig.devTypeTxTypeCode,
          devTypeDataTypeCode: conConfig.devTypeDataTypeCode,
          txConf: {
            confId: undefined,
            devTypeId: undefined,
            jdtParamConfDesc: '',
            jdtParamConfFlag: '1',
            paramConfDataList: [],
            sort: '0'
          }
        }
      }
    } else if (conConfig.devTypeDataTypeCode == '0020') {
      let modbusConf = conConfig.paramConfList as DeviceType.ParamConfMODBUS[]

      const txConf: AddDevType.TxConf_MODBUS[] = modbusConf.map(paramConf => ({
        confId: paramConf.confId,
        devTypeId: paramConf.devTypeId,
        mdtParamConfDesc: paramConf.mdtParamConfDesc || '',
        addressCode: paramConf.addressCode,
        paramConfDataList: paramConf.paramConfDataList.map<AddDevType.ParamConfData_MODBUS>(
          paramConfData => ({
            numMade: paramConfData.numMade,
            paramCode: paramConfData.paramCode,
            startHexStr: paramConfData.startHexStr,
            dataType: paramConfData.dataType,
            byteType: paramConfData.byteType,
            reserveNum: paramConfData.reserveNum,
            confId: paramConfData.confId,
            confDataId: paramConfData.confDataId,
            paramName: paramConfData.paramName,
            paramDesc: paramConfData.paramDesc || undefined,
            sort: paramConfData.sort
          })
        ),
        sort: paramConf.sort,
        funCode: paramConf.funCode
      }))

      devTypeModuleConConfig = {
        devTypeCCId: conConfig.devTypeCCId,
        devTypeId: conConfig.devTypeId,
        devTypeHeart: conConfig.devTypeHeart,
        devTypeTxTypeCode: conConfig.devTypeTxTypeCode,
        devTypeDataTypeCode: conConfig.devTypeDataTypeCode,
        txConf: txConf
      }
    }

    console.log('设备类型的通信配置转换为通信配置组件所需的数据完成', devTypeModuleConConfig)

    // 存储组件数据
    isUpdate !== false &&
      setDevTypeModuleConConfig(
        (deepClone(devTypeModuleConConfig) as typeof devTypeModuleConConfig) ||
          deepClone(defaultDevTypeModuleConConfig)
      )

    return devTypeModuleConConfig || deepClone(defaultDevTypeModuleConConfig)
  }

  /**设备通信类型列表 */
  const devTypeTxTypeList = computed(() => store.getters['device/devTxTypeList'])
  function updateDevTypeTxTypeList() {
    store.dispatch('device/updateDevTxTypeList')
  }

  /**设备基本信息列表 */
  const getDevTypeDataTypeList = computed(() => store.getters['device/devDataTypeList'])
  const updateDevTypeDataTypeList = () => {
    store.dispatch('device/updateDevDataTypeList')
  }

  // -----------------------------------数据类型转换 DeviceType.ConConfig 转为 AddType.DevTypeConConfigSign-----------------------------------
  function devConConfig2devTypeModuleConConfig(
    conConfig: DeviceType.ConConfig,
    isUpdate?: boolean
  ): AddDevType.DevTypeConConfigSign {
    //   // 存储原始数据
    isUpdate !== false &&
      setDevTypeConConfig(deepClone(conConfig) as typeof defaultDevTypeConConfig)

    let devCon: AddDevType.DevTypeConConfigSign = {
      devTypeCCId: conConfig.devTypeCCId,
      devTypeId: conConfig.devTypeId,
      devTypeHeart: conConfig.devTypeHeart,
      devTypeTxTypeCode: conConfig.devTypeTxTypeCode,
      devTypeDataTypeCode: conConfig.devTypeDataTypeCode,
      txConf: {
        devTypeId: undefined,
        jdtParamConfDesc: '',
        confId: undefined,
        jdtParamConfFlag: '1',
        paramConfDataList: [],
        sort: '0'
      }
    }

    if (conConfig.devTypeDataTypeCode === '0019') {
      let txConf = devJSONConf2devTypeModuleJSONTxConf(
        conConfig.paramConfList as DeviceType.ParamConfJSON[]
      )
      if (txConf) {
        devCon.txConf = txConf
      }
    } else {
      devCon.txConf = devMODBUSConf2devTypeModuleMODBUSTxConf(
        conConfig.paramConfList as DeviceType.ParamConfMODBUS[]
      )
    }

    isUpdate !== false &&
      setDevTypeModuleConConfig(deepClone(devCon) as typeof defaultDevTypeModuleConConfig)
    return devCon
  }

  function devJSONConf2devTypeModuleJSONTxConf(
    txConfList: DeviceType.ParamConfJSON[]
  ): AddDevType.TxConf_JSON | undefined {
    if (!txConfList.length) return undefined
    let txConf = txConfList[0]
    let devJSONConf: AddDevType.TxConf_JSON = {
      devTypeId: txConf.devTypeId,
      jdtParamConfDesc: txConf.jdtParamConfDesc,
      confId: txConf.confId,
      jdtParamConfFlag: txConf.jdtParamConfFlag,
      sort: txConf.sort,
      paramConfDataList: txConf.paramConfDataList
    }
    return devJSONConf
  }

  function devMODBUSConf2devTypeModuleMODBUSTxConf(
    txConfList: DeviceType.ParamConfMODBUS[]
  ): AddDevType.TxConf_MODBUS[] {
    let devMODBUSConfList: AddDevType.TxConf_MODBUS[] = []

    for (let i = 0; i < txConfList.length; i++) {
      const txConf = txConfList[i]
      let devModBusConf: AddDevType.TxConf_MODBUS = {
        confId: txConf.confId,
        devTypeId: txConf.devTypeId,
        mdtParamConfDesc: txConf.mdtParamConfDesc,
        addressCode: txConf.addressCode,
        funCode: txConf.funCode,
        sort: txConf.sort,
        paramConfDataList: txConf.paramConfDataList
      }
      devMODBUSConfList.push(devModBusConf)
    }
    return devMODBUSConfList
  }

  //----------------------------------- AddType.DevTypeConConfigSign 转为 DeviceType.ConConfig -----------------------------------
  function devTypeModuleConConfig2devConConfig(
    conConfig: AddDevType.DevTypeConConfigSign
  ): DeviceType.ConConfig {
    let devCon: DeviceType.ConConfig = {
      devTypeCCId: conConfig.devTypeCCId,
      devTypeId: conConfig.devTypeId,
      devTypeHeart: conConfig.devTypeHeart,
      devTypeTxTypeCode: conConfig.devTypeTxTypeCode,
      devTypeDataTypeCode: conConfig.devTypeDataTypeCode,
      paramConfList: []
    }
    if (conConfig.devTypeDataTypeCode === '0019') {
      devCon.paramConfList = devTypeModuleJSONTxConf2devJSONConf(
        conConfig.txConf as AddDevType.TxConf_JSON
      )
    } else {
      devCon.paramConfList = devTypeModuleMODBUSTxConf2devMODBUSConf(
        conConfig.txConf as AddDevType.TxConf_MODBUS[]
      )
    }

    return devCon
  }

  function devTypeModuleJSONTxConf2devJSONConf(
    txConf: AddDevType.TxConf_JSON
  ): DeviceType.ParamConfJSON[] {
    let devJSONConf: DeviceType.ParamConfJSON = {
      devTypeId: txConf.devTypeId,
      jdtParamConfDesc: txConf.jdtParamConfDesc,
      confId: txConf.confId,
      jdtParamConfFlag: txConf.jdtParamConfFlag,
      sort: txConf.sort,
      paramConfDataList: txConf.paramConfDataList
    }

    return [devJSONConf]
  }

  function devTypeModuleMODBUSTxConf2devMODBUSConf(
    txConfList: AddDevType.TxConf_MODBUS[]
  ): DeviceType.ParamConfMODBUS[] {
    let devMODBUSConfList: DeviceType.ParamConfMODBUS[] = []

    for (let i = 0; i < txConfList.length; i++) {
      const txConf = txConfList[i]
      let devModBusConf: DeviceType.ParamConfMODBUS = {
        confId: txConf.confId,
        devTypeId: txConf.devTypeId,
        mdtParamConfDesc: txConf.mdtParamConfDesc,
        addressCode: txConf.addressCode,
        funCode: txConf.funCode,
        sort: txConf.sort,
        paramConfDataList: txConf.paramConfDataList
      }

      devMODBUSConfList.push(devModBusConf)
    }
    return devMODBUSConfList
  }

  //----------------------------------- JSON监测参数列表 操作属性 处理 -----------------------------------

  /**
   *
   * @param defaultTxConf 原始 JSON协议 监测参数列表
   * @param txConf 组件 JSON协议 监测参数列表
   * @returns
   */
  function handleMakePropertyByJSONConConf(
    defaultTxConf: AddDevType.TxConf_JSON<AddDevType.ParamConfData_JSON>,
    txConf: EditDevTypeConConfigOptionParamConfJSON
  ): boolean {
    // 原始的JSON协议配置监测参数列表
    let defaultParamConfDataList = defaultTxConf.paramConfDataList

    // 组件的JSON协议配置监测参数列表
    let paramConfDataList = txConf.paramConfDataList

    // 配置没有confId，会出现在以下情况中出现
    // 1. 添加设备类型的时候未配置通信协议
    if (!txConf.confId) {
      txConf.makeProperty = 'add'
      if (!txConf.paramConfDataList.length) {
        message.warning('请添加参数')
        return false
      }

      for (let i = 0; i < txConf.paramConfDataList.length; i++) {
        const paramConfData = txConf.paramConfDataList[i]
        paramConfData.confId = txConf.confId

        let flag = JSONParamConfDataIsOk(paramConfData)

        if (!flag) return false

        paramConfData.makeProperty = 'add'
      }
    } else {
      // 存在对应的JSON协议配置时

      // 将JSON协议配置的操作属性设为空

      // 判断操作属性是添加（add）、修改(edit)
      for (let i = 0; i < paramConfDataList.length; i++) {
        // 组件的JSON协议配置监测参数
        const paramConfData = paramConfDataList[i]
        paramConfData.confId = txConf.confId

        // 校验JSON协议的参数配置是否完整
        // 校验内自带错误提示
        let flag = JSONParamConfDataIsOk(paramConfData)
        if (!flag) return false

        // 在 defaultParamConfDataIndex 中查询是否存在与paramConfData.confDataId相同的项
        const defaultParamConfDataIndex = defaultParamConfDataList.findIndex(
          item => item.confDataId === paramConfData.confDataId
        )

        /**如果有值 比对必要属性是否相同 */
        if (defaultParamConfDataIndex !== -1) {
          // 原始的JSON配置监测参数
          const defaultParamConfData = defaultParamConfDataList[defaultParamConfDataIndex]

          console.log(defaultParamConfData, paramConfData)
          let flag = JSONParamConfDataIsDiff(defaultParamConfData, paramConfData)
          if (flag) {
            // 如果不同将操纵属性改为edit
            paramConfData.makeProperty = 'edit'
            txConf.makeProperty = 'edit'
          } else {
            paramConfData.makeProperty = ''
          }
        } else {
          // 如果没值 视为添加
          paramConfData.makeProperty = 'add'
          txConf.makeProperty = 'edit'
        }
      }

      // 处理删除掉的参数
      for (let i = 0; i < defaultParamConfDataList.length; i++) {
        // 原始的JSON配置监测参数
        const defaultParamConfData = defaultParamConfDataList[i]

        // 在组件的监测参数列表中查询不到时
        let paramConfDataIndex = paramConfDataList.findIndex(
          item => item.confDataId === defaultParamConfData.confDataId
        )

        // paramConfDataIndex为-1 表示用户已将此参数删除
        if (paramConfDataIndex === -1) {
          //! 这里的判断只是做一个验证
          // 一般来说defaultParamConfData里面所有的数据都是完整的
          // 组件中是将其直接从数组中删除掉
          // 所以这里要将数据加回来，发给后端在数据库中删除
          if (defaultParamConfData.confId && defaultParamConfData.confDataId) {
            paramConfDataList.push({
              confId: defaultParamConfData.confId,
              confDataId: defaultParamConfData.confDataId,
              paramCode: defaultParamConfData.paramCode,
              paramName: defaultParamConfData.paramName,
              paramDesc: defaultParamConfData.paramDesc,
              reserveNum: defaultParamConfData.reserveNum,
              sort: defaultParamConfData.sort,
              makeProperty: 'delete'
            })
          }
        }
      }
    }
    return true
  }

  //----------------------------------- MODBUS数据集 操作属性 处理 -----------------------------------

  /**
   *
   * @param defaultTxConfList 原始 MODBUS协议 参数集
   * @param txConfList 组件 MODBUS协议 参数集
   * @returns
   */
  function handleMakePropertyByMODBUSConConfList(
    defaultTxConfList: AddDevType.TxConf_MODBUS<AddDevType.ParamConfData_MODBUS>[],
    txConfList: EditDevTypeConConfigOptionParamConfMODBUS[]
  ): boolean {
    // 处理参数集
    for (let i = 0; i < txConfList.length; i++) {
      const txConf = txConfList[i]

      let isOk = MODBUSTxConfDataIsOk(txConf)

      if (!isOk) return false

      let defaultTxConfIndex = defaultTxConfList.findIndex(item => item.confId === txConf.confId)

      let defaultTxConf = defaultTxConfList[defaultTxConfIndex]

      if (!defaultTxConf) {
        // 原始参数集中没有对应的数据集，视为添加
        txConf.makeProperty = 'add'

        // 数据集添加时，内部所有参数的操作属性都为添加
        for (let j = 0; j < txConf.paramConfDataList.length; j++) {
          const paramConfData = txConf.paramConfDataList[j]
          paramConfData.makeProperty = 'add'
        }
      } else {
        let flag = MODBUSTxConfDataIsDiff(defaultTxConf, txConf)

        if (flag) txConf.makeProperty = 'edit'

        let confDataListIsOk = handleMakePropertyByMODBUSConConfDataList(defaultTxConf, txConf)

        if (!confDataListIsOk) return false
      }
    }

    // 处理删除掉的参数集
    for (let i = 0; i < defaultTxConfList.length; i++) {
      const defaultTxConf = defaultTxConfList[i]

      let txConfIndex = txConfList.findIndex(item => item.confId === defaultTxConf.confId)

      // txConfIndex为-1 表示用户已将此参数集删除
      if (txConfIndex === -1) {
        if (defaultTxConf.confId && defaultTxConf.devTypeId) {
          txConfList.push({
            addressCode: defaultTxConf.addressCode,
            funCode: defaultTxConf.funCode,
            confId: defaultTxConf.confId,
            devTypeId: defaultTxConf.devTypeId,
            sort: defaultTxConf.sort,
            mdtParamConfDesc: defaultTxConf.mdtParamConfDesc,
            makeProperty: 'delete',
            paramConfDataList:
              defaultTxConf.paramConfDataList.map<EditDevTypeConConfigOptionParamConfDataMODBUS>(
                item => ({
                  confId: item.confId,
                  confDataId: item.confDataId,
                  paramCode: item.paramCode,
                  dataType: item.dataType,
                  startHexStr: item.startHexStr,
                  numMade: item.numMade,
                  reserveNum: Number(item.reserveNum),
                  byteType: item.byteType,
                  paramName: item.paramName,
                  paramDesc: item.paramDesc,
                  sort: item.sort,
                  makeProperty: 'delete'
                })
              )
          })
        }
      }
    }
    return true
  }

  //----------------------------------- MODBUS监测参数列表 操作属性 处理 -----------------------------------
  /**
   *
   * @param defaultTxConf 原始 MODBUS协议 监测参数列表
   * @param txConf 组件 MODBUS协议 监测参数列表
   * @returns
   */
  function handleMakePropertyByMODBUSConConfDataList(
    defaultTxConf: AddDevType.TxConf_MODBUS<AddDevType.ParamConfData_MODBUS>,
    txConf: EditDevTypeConConfigOptionParamConfMODBUS
  ): boolean {
    let defaultParamConfDataList = defaultTxConf.paramConfDataList

    let paramConfDataList = txConf.paramConfDataList

    for (let j = 0; j < paramConfDataList.length; j++) {
      const paramConfData = paramConfDataList[j]
      let flag = MODBUSParamConfDataIsOk(paramConfData)

      if (!flag) return false
      /**
       * 初始将MODBUS所有参数的操作属性改为delete
       *
       * 通过后续对比 在更改为edit add 或者 空字符
       */
      let defaultParamConfDataIndex = defaultParamConfDataList.findIndex(
        item => item.confDataId === paramConfData.confDataId
      )
      let defaultParamConfData = defaultParamConfDataList[defaultParamConfDataIndex]

      if (!defaultParamConfData) {
        paramConfData.makeProperty = 'add'
      } else {
        let flag = MODBUSParamConfDataIsDiff(defaultParamConfData, paramConfData)

        if (flag) {
          // 如果不同将操纵属性改为edit
          paramConfData.makeProperty = 'edit'
        } else {
          // 如果相同操纵属性改为空字符
          paramConfData.makeProperty = ''
        }
      }
    }

    // 处理删除掉的参数
    for (let i = 0; i < defaultParamConfDataList.length; i++) {
      const defaultParamConfData = defaultParamConfDataList[i]

      let paramConfDataIndex = paramConfDataList.findIndex(
        item => item.confDataId === defaultParamConfData.confDataId
      )
      // paramConfDataIndex为-1 表示用户已将此参数删除
      if (paramConfDataIndex === -1) {
        if (defaultParamConfData.confId && defaultParamConfData.confDataId) {
          paramConfDataList.push({
            confId: defaultParamConfData.confId,
            confDataId: defaultParamConfData.confDataId,
            paramCode: defaultParamConfData.paramCode,
            paramName: defaultParamConfData.paramName,
            paramDesc: defaultParamConfData.paramDesc,
            reserveNum: Number(defaultParamConfData.reserveNum),
            sort: defaultParamConfData.sort,
            dataType: defaultParamConfData.dataType,
            startHexStr: defaultParamConfData.startHexStr,
            numMade: defaultParamConfData.numMade,
            byteType: defaultParamConfData.byteType,
            makeProperty: 'delete'
          })
        }
      }
    }
    return true
  }

  // ----------------------------------- 数据校验 -----------------------------------

  /**
   * 传入两个JSON协议的检测参数配置，比较是否有数据不同
   *
   * @return boolean  true:不同 false:相同
   *  */
  function JSONParamConfDataIsDiff(
    defaultData: AddDevType.ParamConfData_JSON,
    currentData: AddDevType.ParamConfData_JSON
  ): boolean {
    if (defaultData.confId !== currentData.confId) {
      console.error(defaultData)
      console.error(currentData)
      return true
    }
    if (defaultData.confDataId !== currentData.confDataId) {
      console.error(defaultData)
      console.error(currentData)
      return true
    }
    if (defaultData.paramCode !== currentData.paramCode) {
      console.error(defaultData)
      console.error(currentData)
      return true
    }
    if (defaultData.paramDesc !== currentData.paramDesc) {
      console.error(defaultData)
      console.error(currentData)
      return true
    }
    if (defaultData.sort !== currentData.sort) {
      console.error(defaultData)
      console.error(currentData)
      return true
    }
    if (defaultData.reserveNum != currentData.reserveNum) {
      console.error(defaultData)
      console.error(currentData)
      return true
    }
    if (defaultData.paramName !== currentData.paramName) {
      console.error(defaultData)
      console.error(currentData)
      return true
    }
    return false
  }

  /**
   * 传入JSON协议的检测参数配置，查看数据是否完整
   *
   * @return boolean  true:完整 false:不完整
   *  */
  function JSONParamConfDataIsOk(data: AddDevType.ParamConfData_JSON): boolean {
    if (!data.paramCode) {
      console.error(data)
      message.warning('请选择监测参数')
      return false
    }

    if (!data.sort) {
      console.error(data)
      return false
    }

    let reserveNum = Number(data.reserveNum)
    if (isNaN(reserveNum)) {
      console.error(data)
      message.warning('请输入保留位数')
      return false
    }

    if (data.reserveNum === '') {
      console.error(data)
      message.warning('请输入保留位数')
      return false
    }

    // 不用判断检测参数名称
    // 选择的时候会自动赋值
    // if (!data.paramName) {
    //   console.error(data)
    //   return false
    // }

    return true
  }

  /**
   * 传入两个MODBUS协议的检测参数配置，比较是否有数据不同
   *
   * @return boolean  true:不同 false:相同
   *  */
  function MODBUSParamConfDataIsDiff(
    defaultData: AddDevType.ParamConfData_MODBUS,
    currentData: EditDevTypeConConfigOptionParamConfDataMODBUS
  ): boolean {
    if (defaultData.confId !== currentData.confId) {
      console.error(defaultData)
      console.error(currentData)
      return true
    }
    if (defaultData.confDataId !== currentData.confDataId) {
      console.error(defaultData)
      console.error(currentData)
      return true
    }
    if (defaultData.paramCode !== currentData.paramCode) {
      console.error(defaultData)
      console.error(currentData)
      return true
    }
    if (defaultData.paramName !== currentData.paramName) {
      console.error(defaultData)
      console.error(currentData)
      return true
    }
    if (defaultData.reserveNum != currentData.reserveNum) {
      console.error(defaultData)
      console.error(currentData)
      return true
    }
    if (defaultData.byteType !== currentData.byteType) {
      console.error(defaultData)
      console.error(currentData)
      return true
    }
    if (defaultData.dataType !== currentData.dataType) {
      console.error(defaultData)
      console.error(currentData)
      return true
    }
    if (defaultData.startHexStr !== currentData.startHexStr) {
      console.error(defaultData)
      console.error(currentData)
      return true
    }
    if (defaultData.numMade !== currentData.numMade) {
      console.error(defaultData)
      console.error(currentData)
      return true
    }
    if (defaultData.paramDesc !== currentData.paramDesc) {
      console.error(defaultData)
      console.error(currentData)
      return true
    }
    if (defaultData.sort !== currentData.sort) {
      console.error(defaultData)
      console.error(currentData)
      return true
    }

    return false
  }

  /**
   * 传入两个MODBUS协议的通信配置，比较是否有数据不同
   *
   * @return boolean  true:不同 false:相同
   *  */
  function MODBUSTxConfDataIsDiff(
    defaultData: AddDevType.TxConf_MODBUS,
    currentData: EditDevTypeConConfigOptionParamConfMODBUS
  ): boolean {
    if (defaultData.confId !== currentData.confId) {
      console.error(defaultData)
      console.error(currentData)
      return true
    }
    if (defaultData.devTypeId !== currentData.devTypeId) {
      console.error(defaultData)
      console.error(currentData)
      return true
    }
    if (defaultData.funCode !== currentData.funCode) {
      console.error(defaultData)
      console.error(currentData)
      return true
    }
    if (currentData.paramConfDataList.length === 0) {
      message.error('有参数集的监测参数为空')
      return true
    }
    if (defaultData.addressCode !== currentData.addressCode) {
      console.error(defaultData)
      console.error(currentData)
      return true
    }
    if (defaultData.mdtParamConfDesc !== currentData.mdtParamConfDesc) {
      console.error(defaultData)
      console.error(currentData)
      return true
    }
    if (defaultData.sort !== currentData.sort) {
      console.error(defaultData)
      console.error(currentData)
      return true
    }
    return false
  }

  /**
   * 传入MODBUS协议的通信配置，检测数据是否完整
   *
   * @return boolean  true:完整 false: 不完整
   *  */
  function MODBUSTxConfDataIsOk(data: EditDevTypeConConfigOptionParamConfMODBUS): boolean {
    if (!data.addressCode) {
      console.error(data)
      message.warning('请485地址')

      return false
    }

    if (!data.funCode) {
      console.error(data)
      message.warning('请功能码')
      return false
    }

    return true
  }

  /**
   * 传入MODBUS协议的参数配置，检测数据是否完整
   *
   * @return boolean  true:完整 false: 不完整
   *  */
  function MODBUSParamConfDataIsOk(data: EditDevTypeConConfigOptionParamConfDataMODBUS): boolean {
    if (!data.paramCode) {
      console.error(data)
      message.warning('请选择监测参数')

      return false
    }

    let reserveNum = Number(data.reserveNum)
    if (isNaN(reserveNum)) {
      console.error(data)
      message.warning('请输入保留位数')
      return false
    }

    if (!data.startHexStr) {
      console.error(data)
      message.warning('请输入起始位')
      return false
    }

    if (data.startHexStr.length !== 4) {
      console.error(data)
      message.warning('起始位长度必须为4')
      return false
    }

    return true
  }

  const getDevTypeModuleConConfigOperatingrecord = computed<EditDevTypeConConfigOption | undefined>(
    () => {
      if (!devTypeConConfig.value.devTypeId) {
        return undefined
      }

      if (!devTypeModuleConConfig.value.devTypeId) {
        return undefined
      }

      /**
       * 将 AddDevType.DevTypeConConfigSign 转为 EditdevConConfigOption
       *
       * 方便添加makeProperty
       *  */
      let returnData: EditDevTypeConConfigOption | undefined = undefined

      // JSON协议处理
      if (devTypeConConfig.value.devTypeDataTypeCode === '0019') {
        // 获取原始数据
        let defaultModuleConConfig = devConConfig2devTypeModuleConConfig(
          deepClone(devTypeConConfig.value),
          false
        ) as AddDevType.DevTypeConConfigSign<AddDevType.TxConf_JSON>
        let defaultTxConf = defaultModuleConConfig.txConf

        /**组件的JSON协议配置 */
        let moduleConConfig = deepClone(
          devTypeModuleConConfig.value
        ) as AddDevType.DevTypeConConfigSign<EditDevTypeConConfigOptionParamConfJSON>

        let txConf = moduleConConfig.txConf

        handleMakePropertyByJSONConConf(defaultTxConf, txConf)

        returnData = {
          devTypeCCId: moduleConConfig.devTypeCCId,
          devTypeId: moduleConConfig.devTypeId,
          devTypeTxTypeCode: moduleConConfig.devTypeTxTypeCode,
          devTypeDataTypeCode: moduleConConfig.devTypeDataTypeCode,
          devTypeHeart: moduleConConfig.devTypeHeart,
          paramConfList: [moduleConConfig.txConf]
        }
      } else {
        // MODBUS协议处理

        // 获取原始数据
        let defaultModuleConConfig = devConConfig2devTypeModuleConConfig(
          devTypeConConfig.value,
          false
        ) as AddDevType.DevTypeConConfigSign<AddDevType.TxConf_MODBUS[]>

        // 原始参数集
        let defaultTxConfList = defaultModuleConConfig.txConf

        // 组件参数集
        let moduleConConfig = deepClone(
          devTypeModuleConConfig.value
        ) as AddDevType.DevTypeConConfigSign<EditDevTypeConConfigOptionParamConfMODBUS[]>

        // 组件参数集
        let txConfList = moduleConConfig.txConf

        handleMakePropertyByMODBUSConConfList(defaultTxConfList, txConfList)

        returnData = {
          devTypeCCId: moduleConConfig.devTypeCCId,
          devTypeId: moduleConConfig.devTypeId,
          devTypeTxTypeCode: moduleConConfig.devTypeTxTypeCode,
          devTypeDataTypeCode: moduleConConfig.devTypeDataTypeCode,
          devTypeHeart: moduleConConfig.devTypeHeart,
          paramConfList: moduleConConfig.txConf
        }
      }

      return returnData
    }
  )

  return {
    devTypeConConfig,
    devTypeModuleConConfig,
    devTypeConConfig2devTypeModuleConConfig,
    initDevTypeConConfig,
    devTypeTxTypeList,
    updateDevTypeTxTypeList,
    devTypeDataTypeList: getDevTypeDataTypeList,
    updateDevTypeDataTypeList,
    getDevTypeModuleConConfigOperatingrecord
  }
}

export default useDevTypeConConfig
